{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/jr/2rmk5tps6b1241pzkg7pv8rr0000gn/T/ipykernel_49752/1637782986.py:39: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.rcParams[\"font.family\"] = \"SimHei\"\n",
    "plt.rcParams[\"axes.unicode_minus\"] = False\n",
    "\n",
    "velocity = {\n",
    "    \"norm\": lambda density: np.polyval(\n",
    "        np.convolve([-0.36, 1.49], [112, -380, 434, -217, 57]), density\n",
    "    ),\n",
    "    \"door\": lambda density: velocity[\"norm\"](density)\n",
    "    * (1.17 + 0.13 * np.sin(6.03 * density - 0.12)),\n",
    "    \"stair\": lambda density: velocity[\"norm\"](density)\n",
    "    * (0.775 + 0.44 * np.exp(-0.39 * density) * np.sin(5.16 * density - 0.224))\n",
    "    / (1.49 - 0.36 * density),\n",
    "}\n",
    "\n",
    "# velocity_norm = lambda density: np.polyval(\n",
    "#     np.convolve([-0.36, 1.49], [112, -380, 434, -217, 57]), density\n",
    "# )\n",
    "# velocity_door = lambda density: velocity_norm(density) * (\n",
    "#     1.17 + 0.13 * np.sin(6.03 * density - 0.12)\n",
    "# )\n",
    "# velocity_stair = (\n",
    "#     lambda density: velocity_norm(density)\n",
    "#     * (0.775 + 0.44 * np.exp(-0.39 * density) * np.sin(5.16 * density - 0.224))\n",
    "#     / (1.49 - 0.36 * density)\n",
    "# )\n",
    "\n",
    "# width = 12\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot()\n",
    "ax.clear()\n",
    "d = np.linspace(0, 1, 100)\n",
    "for name, v in zip(velocity.keys(), velocity.values()):\n",
    "    ax.plot(d, v(d), label=name)\n",
    "ax.legend()\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shortest distance matrix:\n",
      "[[0. 3. 5. 6.]\n",
      " [3. 0. 2. 3.]\n",
      " [5. 2. 0. 1.]\n",
      " [6. 3. 1. 0.]]\n",
      "Shortest path from 0 to 3: [0, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.sparse.csgraph import shortest_path\n",
    "\n",
    "# 定义距离矩阵\n",
    "graph = np.array([[0, 3, 5, np.inf], \n",
    "                  [3, 0, 2, np.inf], \n",
    "                  [5, 2, 0, 1], \n",
    "                  [np.inf, np.inf, 1, 0]])\n",
    "\n",
    "# 指定起点和终点\n",
    "start = 0\n",
    "end = 3\n",
    "\n",
    "# 计算最短路径和路径矩阵\n",
    "dist_matrix, predecessors = shortest_path(graph, method='D', directed=False, return_predecessors=True)\n",
    "\n",
    "# 输出最短距离矩阵\n",
    "print(\"Shortest distance matrix:\")\n",
    "print(dist_matrix)\n",
    "\n",
    "# 构建从起点到终点的路径\n",
    "path = []\n",
    "step = end\n",
    "while step != start:\n",
    "    path.append(step)\n",
    "    step = predecessors[start, step]\n",
    "path.append(start)\n",
    "path = path[::-1]  # 反转路径，使其从起点到终点\n",
    "\n",
    "# 输出最短路径\n",
    "print(f\"Shortest path from {start} to {end}: {path}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.,  5.],\n",
       "       [15.,  5.],\n",
       "       [ 5., 15.],\n",
       "       [15., 15.],\n",
       "       [ 5., 25.],\n",
       "       [15., 25.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def generate_grid_centers(coord0, wh, step=10):\n",
    "    \"\"\"\n",
    "    生成给定矩形的10x10小正方形的中心坐标。\n",
    "    \n",
    "    参数:\n",
    "    coord0 (tuple): 矩形的左下角坐标 (x0, y0)。\n",
    "    wh (tuple): 矩形的宽度和高度 (w, h)。\n",
    "    \n",
    "    返回:\n",
    "    list: 所有小正方形的中心坐标 [(x, y), ...]。\n",
    "    \"\"\"\n",
    "    x0, y0 = coord0\n",
    "    w, h = wh\n",
    "    \n",
    "    # 确保矩形的边长是10的倍数\n",
    "    if w % step != 0 or h % step != 0:\n",
    "        raise ValueError(\"矩形的边长必须是10的倍数\")\n",
    "    \n",
    "    # 生成网格点\n",
    "    x = np.arange(x0 + step / 2, x0 + w, step)\n",
    "    y = np.arange(y0 + step / 2, y0 + h, step)\n",
    "    \n",
    "    # 使用 meshgrid 生成所有点\n",
    "    X, Y = np.meshgrid(x, y)\n",
    "    \n",
    "    # 将网格点展平成列表\n",
    "    centers = list(zip(X.ravel(), Y.ravel()))\n",
    "    \n",
    "    return np.array(centers)\n",
    "\n",
    "# 示例用法\n",
    "coord0 = (0, 0)\n",
    "delta = (20, 30)  # 这里宽度和高度都是10的倍数\n",
    "generate_grid_centers(coord0, delta)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 4) (2, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x, y = (zip(*np.array([(1, 2), (3, 4), (4, 5)])))\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (0, 1)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 1)\t1\n"
     ]
    }
   ],
   "source": [
    "from scipy.sparse import csr_matrix\n",
    "from scipy.sparse.csgraph import shortest_path\n",
    "\n",
    "print(csr_matrix(\n",
    "    [\n",
    "        [0, 1, 1],\n",
    "        [1, 0, 1],\n",
    "        [1, 1, 0],\n",
    "    ]\n",
    "))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([0, 1, 3], [1, 3], [2, 3], [3], [4, 3], [5, 2, 3])\n",
      "(2, 1, 1, 0, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "import networkx as nx # type: ignore\n",
    "import numpy as np # type: ignore\n",
    "import pandas as pd\n",
    "\n",
    "row=np.array([0,0,0,1,1,2,2,5,4])\n",
    "col=np.array([1,2,5,2,3,5,3,4,3])\n",
    "value=np.array([7,9,14,10,15,2,11,9,6])\n",
    "graph = nx.Graph()\n",
    "graph.add_nodes_from(set([*row, *col]))\n",
    "graph.add_weighted_edges_from(zip(row, col,  value))\n",
    "# pd.DataFrame(map(lambda x: [*x[:-1], x[-1][\"weight\"]], graph.edges(data=True)), columns=[\"结点i\", \"结点j\", \"权重\"])\n",
    "pathes = nx.shortest_path(graph, target=3)\n",
    "distances = nx.shortest_path_length(graph, target=3)\n",
    "numbers, pathes, distances = list(zip(*sorted(zip(pathes.keys(), pathes.values(), distances.values()), key=lambda x: x[0])))\n",
    "# pd.DataFrame(\n",
    "#     {\n",
    "#         \"source(number)\": numbers,\n",
    "#         \"source(coord)\": nodes[numbers],\n",
    "#         \"path\": nodes[pathes],\n",
    "#         \"distance\": distances,\n",
    "#     }\n",
    "# )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 1 0 3]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 示例矩阵，矩阵的形状是 (4, n)\n",
    "matrix = np.array([[False, False, True, False],\n",
    "                   [False, True, False, False],\n",
    "                   [True, False, False, False],\n",
    "                   [False, False, False, True]])\n",
    "\n",
    "# 获取每列中布尔值 True 的行索引\n",
    "indices = np.argmax(matrix, axis=0)\n",
    "\n",
    "print(indices)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[main e5e5267] louvre\n",
      " 1 file changed, 39 insertions(+), 2 deletions(-)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "remote: Powered by \u001b[01;33mGITEE.COM \u001b[0m[1.1.5]        \n",
      "remote: Set trace flag 134861b5        \n",
      "To https://gitee.com/J3750/Louvre-Escape.git\n",
      "   5e3d411..e5e5267  main -> main\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "push once\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[2], line 5\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mos\u001b[39;00m\n\u001b[1;32m      4\u001b[0m os\u001b[38;5;241m.\u001b[39msystem(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/Users/wangjie/Documents/Python/卢浮宫大逃亡/push.sh\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 5\u001b[0m time\u001b[38;5;241m.\u001b[39msleep(\u001b[38;5;241m3\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m60\u001b[39m)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    import time\n",
    "    import os\n",
    "    os.system(\"/Users/wangjie/Documents/Python/卢浮宫大逃亡/push.sh\")\n",
    "    time.sleep(3 * 60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'numpy.ndarray' object has no attribute 'save'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[19], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m np\u001b[38;5;241m.\u001b[39mconcatenate(\u001b[38;5;28mtuple\u001b[39m(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: x, [[\u001b[38;5;241m1\u001b[39m], [\u001b[38;5;241m2\u001b[39m], [\u001b[38;5;241m3\u001b[39m]])), axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m.\u001b[39msave(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'save'"
     ]
    }
   ],
   "source": [
    "np.concatenate(tuple(map(lambda x: x, [[1], [2], [3]])), axis=0).save(\"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "pd.DataFrame(np.array([\n",
    "    [1, 2],\n",
    "    [3, 4],\n",
    "    [4, 5],\n",
    "]), columns=[\"x\", \"y\"]).to_excel(\"1.xlsx\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.array([1, 2]) == np.array([[1, 2], [3, 4]])).all(axis=1).any()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "with pd.ExcelWriter(\"1.xlsx\") as writer:\n",
    "    pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]}).to_excel(writer, sheet_name=\"1\")\n",
    "    pd.DataFrame().to_excel(writer, sheet_name=\"2\")\n",
    "    pd.DataFrame().to_excel(writer, sheet_name=\"3\")\n",
    "    # writer.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [1, 2],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.array([\n",
    "    [1, 2],\n",
    "    [1, 2],\n",
    "    [1, 2],\n",
    "    [1, 2],\n",
    "    [1, 2],\n",
    "    [1, 2],\n",
    "])[[1, 3, 4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>source</th>\n",
       "      <th>path</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[3, 2]</td>\n",
       "      <td>[[3, 1], [2, 3]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[3, 2]</td>\n",
       "      <td>[[3, 1], [2, 3]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[3, 2]</td>\n",
       "      <td>[[3, 1], [2, 3], [4, 5]]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   source                      path\n",
       "0  [3, 2]          [[3, 1], [2, 3]]\n",
       "1  [3, 2]          [[3, 1], [2, 3]]\n",
       "2  [3, 2]  [[3, 1], [2, 3], [4, 5]]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame({\n",
    "    \"source\": [\n",
    "        np.array([3, 2]),\n",
    "        np.array([3, 2]),\n",
    "        np.array([3, 2]),\n",
    "    ],\n",
    "    \"path\": [\n",
    "        np.array([[3, 1], [2, 3]]),\n",
    "        np.array([[3, 1], [2, 3]]),\n",
    "        np.array([[3, 1], [2, 3], [4, 5]]),\n",
    "    ],\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/jr/2rmk5tps6b1241pzkg7pv8rr0000gn/T/ipykernel_7302/3121186285.py:7: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot()\n",
    "ax.scatter([1], [1], label=\"1\")\n",
    "ax.legend(loc=\"lower right\", bbox_to_anchor=(1.15, 0))\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>src</th>\n",
       "      <th>core</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   src  core\n",
       "2    3     3"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame({\n",
    "    \"src\": [1, 2, 3, 4, 5],\n",
    "    \"core\": [1, 2, 3, 4, 5],\n",
    "})\n",
    "df[df[\"src\"] == 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pulp\n",
    "\n",
    "prob = pulp.LpProblem()\n",
    "dis = np.random.randint(10, size=(3, 4))\n",
    "x = pulp.LpVariable.dicts(\"x\", (range(dis.shape[0]), range(dis.shape[1])), cat=pulp.LpBinary)\n",
    "x = np.array(list(map(lambda x: list(x.values()), x.values())))\n",
    "prob += (dis * x).sum() == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 3]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.array([\n",
    "    [1, 0, 0],\n",
    "    [0, 1, 0],\n",
    "    [0, 0, 0],\n",
    "    [0, 0, 1],\n",
    "])\n",
    "[(np.where(i == 1)[0][0]) for i in a.T]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1.099998354277713,\n",
       " 1.099999921632272,\n",
       " -1.0999935280676159,\n",
       " 1.0999808228719061)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.pie([1, 3, 4, 5], labels=[\"d\", \"f\", \"v\", \"1\"], autopct='%1.1f%%')\n",
    "plt.axis('equal')  # 显示为圆（避免比例压缩为椭圆）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34.883102501974"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "348831.02501974 / 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "430.3195105370496"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6.33e5 / 1471"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'shape'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[76], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpulp\u001b[39;00m\n\u001b[1;32m      2\u001b[0m x \u001b[38;5;241m=\u001b[39m pulp\u001b[38;5;241m.\u001b[39mLpVariable\u001b[38;5;241m.\u001b[39mdicts(\n\u001b[0;32m----> 3\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m, (\u001b[38;5;28mrange\u001b[39m(distances\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]), \u001b[38;5;28mrange\u001b[39m(distances\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m])), cat\u001b[38;5;241m=\u001b[39mpulp\u001b[38;5;241m.\u001b[39mLpBinary\n\u001b[1;32m      4\u001b[0m )\n\u001b[1;32m      5\u001b[0m x \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(\u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[38;5;28mlist\u001b[39m(x\u001b[38;5;241m.\u001b[39mvalues()), x\u001b[38;5;241m.\u001b[39mvalues())))\n\u001b[1;32m      6\u001b[0m p \u001b[38;5;241m=\u001b[39m pulp\u001b[38;5;241m.\u001b[39mLpProblem()\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'shape'"
     ]
    }
   ],
   "source": [
    "import pulp\n",
    "x = pulp.LpVariable.dicts(\n",
    "    \"x\", (range(distances.shape[0]), range(distances.shape[1])), cat=pulp.LpBinary\n",
    ")\n",
    "x = np.array(list(map(lambda x: list(x.values()), x.values())))\n",
    "p = pulp.LpProblem()\n",
    "p += x.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 0 9 8 6 9 5 5 7 7 2 6 1 3 8 2 6 9 0 0 5 8 7 2 1 9 6 8 5 1]\n",
      " [6 2 1 6 4 4 1 4 4 4 6 8 7 6 5 9 9 2 3 7 8 0 1 1 4 3 7 4 1 0]\n",
      " [1 3 9 9 6 6 6 0 9 6 8 6 4 7 1 0 8 9 0 9 7 5 0 1 7 0 7 5 5 6]\n",
      " [1 3 5 0 7 3 7 6 1 7 6 9 8 3 3 8 9 1 0 9 7 4 5 3 2 3 0 2 9 5]]\n",
      "[2 0 1 3 1 3 1 2 3 1 0 0 0 0 2 2 0 3 0 0 0 1 2 1 0 2 3 3 1 1]\n",
      "[7 3 9 9 7 9 7 6 9 7 8 9 8 7 8 9 9 9 3 9 8 8 7 3 7 9 7 8 9 6]\n"
     ]
    }
   ],
   "source": [
    "print(a := np.random.randint(10, size=(4, 30)))\n",
    "print(b := a.argmin(axis=0))\n",
    "print(c := a.max(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x15f052c10>"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.scatter([0], [0], s=8, c=\"red\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8284271247461903"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# np.dot(np.array([1, 2]), np.array([3, 4]))\n",
    "np.linalg.norm(np.array([2, 2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5: 0, 4: 1, 3: 2, 2: 3, 1: 4, 0: 5}"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "\n",
    "graph = nx.Graph()\n",
    "graph.add_edge(0, 1, weight=1)\n",
    "graph.add_edge(1, 2, weight=1)\n",
    "graph.add_edge(2, 3, weight=1)\n",
    "graph.add_edge(3, 4, weight=1)\n",
    "graph.add_edge(4, 5, weight=1)\n",
    "nx.shortest_path_length(graph, target=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 2 == 2"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "modeling",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
